home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / lame_src / mpglib / layer3.c < prev    next >
C/C++ Source or Header  |  2000-01-01  |  47KB  |  1,783 lines
  1. #ifdef HAVEMPGLIB
  2. /* 
  3.  * Mpeg Layer-3 audio decoder 
  4.  * --------------------------
  5.  * copyright (c) 1995,1996,1997 by Michael Hipp.
  6.  * All rights reserved. See also 'README'
  7.  */ 
  8.  
  9. #include <stdlib.h>
  10. #include "mpg123.h"
  11. #include "mpglib.h"
  12. #include "huffman.h"
  13. #ifdef PARENT_IS_SLASH
  14. #include "/gtkanal.h"
  15. #else
  16. #include "../gtkanal.h"
  17. #endif
  18.  
  19.  
  20. extern struct mpstr *gmp;
  21.  
  22. #define MPEG1
  23.  
  24.  
  25. static real ispow[8207];
  26. static real aa_ca[8],aa_cs[8];
  27. static real COS1[12][6];
  28. static real win[4][36];
  29. static real win1[4][36];
  30. static real gainpow2[256+118+4];
  31. static real COS9[9];
  32. static real COS6_1,COS6_2;
  33. static real tfcos36[9];
  34. static real tfcos12[3];
  35.  
  36. struct bandInfoStruct {
  37.   short longIdx[23];
  38.   short longDiff[22];
  39.   short shortIdx[14];
  40.   short shortDiff[13];
  41. };
  42.  
  43. int longLimit[9][23];
  44. int shortLimit[9][14];
  45.  
  46. struct bandInfoStruct bandInfo[9] = { 
  47.  
  48. /* MPEG 1.0 */
  49.  { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},
  50.    {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},
  51.    {0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3},
  52.    {4,4,4,4,6,8,10,12,14,18,22,30,56} } ,
  53.  
  54.  { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},
  55.    {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},
  56.    {0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3},
  57.    {4,4,4,4,6,6,10,12,14,16,20,26,66} } ,
  58.  
  59.  { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,
  60.    {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,
  61.    {0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} ,
  62.    {4,4,4,4,6,8,12,16,20,26,34,42,12} }  ,
  63.  
  64. /* MPEG 2.0 */
  65.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  66.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,
  67.    {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} ,
  68.    {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,
  69.                                              /* docs: 332. mpg123: 330 */
  70.  { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,332,394,464,540,576},
  71.    {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,54,62,70,76,36 } ,
  72.    {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} ,
  73.    {4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,
  74.  
  75.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  76.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },
  77.    {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3},
  78.    {4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,
  79. /* MPEG 2.5 */
  80.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
  81.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
  82.    {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
  83.    {4,4,4,6,8,10,12,14,18,24,30,40,18} },
  84.  { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,
  85.    {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},
  86.    {0,12,24,36,54,78,108,144,186,240,312,402,522,576},
  87.    {4,4,4,6,8,10,12,14,18,24,30,40,18} },
  88.  { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},
  89.    {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2},
  90.    {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576},
  91.    {8,8,8,12,16,20,24,28,36,2,2,2,26} } ,
  92. };
  93.  
  94. static int mapbuf0[9][152];
  95. static int mapbuf1[9][156];
  96. static int mapbuf2[9][44];
  97. static int *map[9][3];
  98. static int *mapend[9][3];
  99.  
  100. static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */
  101. static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */
  102.  
  103. static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16];
  104. static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16];
  105.  
  106. static unsigned int get1bit(void)
  107. {
  108.   unsigned char rval;
  109.   rval = *wordpointer << bitindex;
  110.  
  111.   bitindex++;
  112.   wordpointer += (bitindex>>3);
  113.   bitindex &= 7;
  114.  
  115.   return rval>>7;
  116. }
  117.  
  118.  
  119.  
  120.  
  121. /* 
  122.  * init tables for layer-3 
  123.  */
  124. void init_layer3(int down_sample_sblimit)
  125. {
  126.   int i,j,k;
  127.  
  128.   for(i=-256;i<118+4;i++)
  129.     gainpow2[i+256] = pow((double)2.0,-0.25 * (double) (i+210) );
  130.  
  131.   for(i=0;i<8207;i++)
  132.     ispow[i] = pow((double)i,(double)4.0/3.0);
  133.  
  134.   for (i=0;i<8;i++)
  135.   {
  136.     static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037};
  137.     double sq=sqrt(1.0+Ci[i]*Ci[i]);
  138.     aa_cs[i] = 1.0/sq;
  139.     aa_ca[i] = Ci[i]/sq;
  140.   }
  141.  
  142.   for(i=0;i<18;i++)
  143.   {
  144.     win[0][i]    = win[1][i]    = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 );
  145.     win[0][i+18] = win[3][i+18] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
  146.   }
  147.   for(i=0;i<6;i++)
  148.   {
  149.     win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 );
  150.     win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 );
  151.     win[1][i+24] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 );
  152.     win[1][i+30] = win[3][i] = 0.0;
  153.     win[3][i+6 ] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) )  / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 );
  154.   }
  155.  
  156.   for(i=0;i<9;i++)
  157.     COS9[i] = cos( M_PI / 18.0 * (double) i);
  158.  
  159.   for(i=0;i<9;i++)
  160.     tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 );
  161.   for(i=0;i<3;i++)
  162.     tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 );
  163.  
  164.   COS6_1 = cos( M_PI / 6.0 * (double) 1);
  165.   COS6_2 = cos( M_PI / 6.0 * (double) 2);
  166.  
  167.   for(i=0;i<12;i++)
  168.   {
  169.     win[2][i]  = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 );
  170.     for(j=0;j<6;j++)
  171.       COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) );
  172.   }
  173.  
  174.   for(j=0;j<4;j++) {
  175.     static int len[4] = { 36,36,12,36 };
  176.     for(i=0;i<len[j];i+=2)
  177.       win1[j][i] = + win[j][i];
  178.     for(i=1;i<len[j];i+=2)
  179.       win1[j][i] = - win[j][i];
  180.   }
  181.  
  182.   for(i=0;i<16;i++)
  183.   {
  184.     double t = tan( (double) i * M_PI / 12.0 );
  185.     tan1_1[i] = t / (1.0+t);
  186.     tan2_1[i] = 1.0 / (1.0 + t);
  187.     tan1_2[i] = M_SQRT2 * t / (1.0+t);
  188.     tan2_2[i] = M_SQRT2 / (1.0 + t);
  189.  
  190.     for(j=0;j<2;j++) {
  191.       double base = pow(2.0,-0.25*(j+1.0));
  192.       double p1=1.0,p2=1.0;
  193.       if(i > 0) {
  194.         if( i & 1 )
  195.           p1 = pow(base,(i+1.0)*0.5);
  196.         else
  197.           p2 = pow(base,i*0.5);
  198.       }
  199.       pow1_1[j][i] = p1;
  200.       pow2_1[j][i] = p2;
  201.       pow1_2[j][i] = M_SQRT2 * p1;
  202.       pow2_2[j][i] = M_SQRT2 * p2;
  203.     }
  204.   }
  205.  
  206.   for(j=0;j<9;j++)
  207.   {
  208.    struct bandInfoStruct *bi = &bandInfo[j];
  209.    int *mp;
  210.    int cb,lwin;
  211.    short *bdf;
  212.  
  213.    mp = map[j][0] = mapbuf0[j];
  214.    bdf = bi->longDiff;
  215.    for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) {
  216.      *mp++ = (*bdf) >> 1;
  217.      *mp++ = i;
  218.      *mp++ = 3;
  219.      *mp++ = cb;
  220.    }
  221.    bdf = bi->shortDiff+3;
  222.    for(cb=3;cb<13;cb++) {
  223.      int l = (*bdf++) >> 1;
  224.      for(lwin=0;lwin<3;lwin++) {
  225.        *mp++ = l;
  226.        *mp++ = i + lwin;
  227.        *mp++ = lwin;
  228.        *mp++ = cb;
  229.      }
  230.      i += 6*l;
  231.    }
  232.    mapend[j][0] = mp;
  233.  
  234.    mp = map[j][1] = mapbuf1[j];
  235.    bdf = bi->shortDiff+0;
  236.    for(i=0,cb=0;cb<13;cb++) {
  237.      int l = (*bdf++) >> 1;
  238.      for(lwin=0;lwin<3;lwin++) {
  239.        *mp++ = l;
  240.        *mp++ = i + lwin;
  241.        *mp++ = lwin;
  242.        *mp++ = cb;
  243.      }
  244.      i += 6*l;
  245.    }
  246.    mapend[j][1] = mp;
  247.  
  248.    mp = map[j][2] = mapbuf2[j];
  249.    bdf = bi->longDiff;
  250.    for(cb = 0; cb < 22 ; cb++) {
  251.      *mp++ = (*bdf++) >> 1;
  252.      *mp++ = cb;
  253.    }
  254.    mapend[j][2] = mp;
  255.  
  256.   }
  257.  
  258.   for(j=0;j<9;j++) {
  259.     for(i=0;i<23;i++) {
  260.       longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;
  261.       if(longLimit[j][i] > (down_sample_sblimit) )
  262.         longLimit[j][i] = down_sample_sblimit;
  263.     }
  264.     for(i=0;i<14;i++) {
  265.       shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;
  266.       if(shortLimit[j][i] > (down_sample_sblimit) )
  267.         shortLimit[j][i] = down_sample_sblimit;
  268.     }
  269.   }
  270.  
  271.   for(i=0;i<5;i++) {
  272.     for(j=0;j<6;j++) {
  273.       for(k=0;k<6;k++) {
  274.         int n = k + j * 6 + i * 36;
  275.         i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12);
  276.       }
  277.     }
  278.   }
  279.   for(i=0;i<4;i++) {
  280.     for(j=0;j<4;j++) {
  281.       for(k=0;k<4;k++) {
  282.         int n = k + j * 4 + i * 16;
  283.         i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12);
  284.       }
  285.     }
  286.   }
  287.   for(i=0;i<4;i++) {
  288.     for(j=0;j<3;j++) {
  289.       int n = j + i * 3;
  290.       i_slen2[n+244] = i|(j<<3) | (5<<12);
  291.       n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15);
  292.     }
  293.   }
  294.  
  295.   for(i=0;i<5;i++) {
  296.     for(j=0;j<5;j++) {
  297.       for(k=0;k<4;k++) {
  298.         int l;
  299.         for(l=0;l<4;l++) {
  300.           int n = l + k * 4 + j * 16 + i * 80;
  301.           n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12);
  302.         }
  303.       }
  304.     }
  305.   }
  306.   for(i=0;i<5;i++) {
  307.     for(j=0;j<5;j++) {
  308.       for(k=0;k<4;k++) {
  309.         int n = k + j * 4 + i * 20;
  310.         n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12);
  311.       }
  312.     }
  313.   }
  314. }
  315.  
  316. /*
  317.  * read additional side information
  318.  */
  319. #ifdef MPEG1 
  320. static void III_get_side_info_1(struct III_sideinfo *si,int stereo,
  321.  int ms_stereo,long sfreq,int single)
  322. {
  323.    int ch, gr;
  324.    int powdiff = (single == 3) ? 4 : 0;
  325.  
  326.    si->main_data_begin = getbits(9);
  327.    if (stereo == 1)
  328.      si->private_bits = getbits_fast(5);
  329.    else 
  330.      si->private_bits = getbits_fast(3);
  331.  
  332.    for (ch=0; ch<stereo; ch++) {
  333.        si->ch[ch].gr[0].scfsi = -1;
  334.        si->ch[ch].gr[1].scfsi = getbits_fast(4);
  335.    }
  336.  
  337.    for (gr=0; gr<2; gr++) 
  338.    {
  339.      for (ch=0; ch<stereo; ch++) 
  340.      {
  341.        register struct gr_info_s *gr_infos = &(si->ch[ch].gr[gr]);
  342.  
  343.        gr_infos->part2_3_length = getbits(12);
  344.        gr_infos->big_values = getbits_fast(9);
  345.        if(gr_infos->big_values > 288) {
  346.           fprintf(stderr,"big_values too large!\n");
  347.           gr_infos->big_values = 288;
  348.        }
  349.        {
  350.      unsigned int qss = getbits_fast(8);
  351.      gr_infos->pow2gain = gainpow2+256 - qss + powdiff;
  352.      if (mpg123_pinfo != NULL) {
  353.        mpg123_pinfo->qss[gr][ch]=qss;
  354.      }
  355.        }
  356.        if(ms_stereo)
  357.          gr_infos->pow2gain += 2;
  358.        gr_infos->scalefac_compress = getbits_fast(4);
  359. /* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
  360.        if(get1bit()) 
  361.        {
  362.          int i;
  363.          gr_infos->block_type = getbits_fast(2);
  364.          gr_infos->mixed_block_flag = get1bit();
  365.          gr_infos->table_select[0] = getbits_fast(5);
  366.          gr_infos->table_select[1] = getbits_fast(5);
  367.  
  368.  
  369.          /*
  370.           * table_select[2] not needed, because there is no region2,
  371.           * but to satisfy some verifications tools we set it either.
  372.           */
  373.          gr_infos->table_select[2] = 0;
  374.          for(i=0;i<3;i++) {
  375.        unsigned int sbg = (getbits_fast(3)<<3);
  376.            gr_infos->full_gain[i] = gr_infos->pow2gain + sbg;
  377.        if (mpg123_pinfo != NULL)
  378.          mpg123_pinfo->sub_gain[gr][ch][i]=sbg/8;
  379.      }
  380.  
  381.  
  382.          if(gr_infos->block_type == 0) {
  383.            fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n");
  384.            exit(1);
  385.          }
  386.          /* region_count/start parameters are implicit in this case. */       
  387.          gr_infos->region1start = 36>>1;
  388.          gr_infos->region2start = 576>>1;
  389.        }
  390.        else 
  391.        {
  392.          int i,r0c,r1c;
  393.          for (i=0; i<3; i++)
  394.            gr_infos->table_select[i] = getbits_fast(5);
  395.          r0c = getbits_fast(4);
  396.          r1c = getbits_fast(3);
  397.          gr_infos->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
  398.          gr_infos->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
  399.          gr_infos->block_type = 0;
  400.          gr_infos->mixed_block_flag = 0;
  401.        }
  402.        gr_infos->preflag = get1bit();
  403.        gr_infos->scalefac_scale = get1bit();
  404.        gr_infos->count1table_select = get1bit();
  405.      }
  406.    }
  407. }
  408. #endif
  409.  
  410. /*
  411.  * Side Info for MPEG 2.0 / LSF
  412.  */
  413. static void III_get_side_info_2(struct III_sideinfo *si,int stereo,
  414.  int ms_stereo,long sfreq,int single)
  415. {
  416.    int ch;
  417.    int powdiff = (single == 3) ? 4 : 0;
  418.  
  419.    si->main_data_begin = getbits(8);
  420.  
  421.    if (stereo == 1)
  422.      si->private_bits = get1bit();
  423.    else 
  424.      si->private_bits = getbits_fast(2);
  425.  
  426.    for (ch=0; ch<stereo; ch++) 
  427.    {
  428.        register struct gr_info_s *gr_infos = &(si->ch[ch].gr[0]);
  429.        unsigned int qss;
  430.  
  431.        gr_infos->part2_3_length = getbits(12);
  432.        gr_infos->big_values = getbits_fast(9);
  433.        if(gr_infos->big_values > 288) {
  434.          fprintf(stderr,"big_values too large!\n");
  435.          gr_infos->big_values = 288;
  436.        }
  437.        qss=getbits_fast(8);
  438.        gr_infos->pow2gain = gainpow2+256 - qss + powdiff;
  439.        if (mpg123_pinfo!=NULL) {
  440.        mpg123_pinfo->qss[0][ch]=qss;
  441.        }
  442.  
  443.  
  444.        if(ms_stereo)
  445.          gr_infos->pow2gain += 2;
  446.        gr_infos->scalefac_compress = getbits(9);
  447. /* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */
  448.        if(get1bit()) 
  449.        {
  450.          int i;
  451.          gr_infos->block_type = getbits_fast(2);
  452.          gr_infos->mixed_block_flag = get1bit();
  453.          gr_infos->table_select[0] = getbits_fast(5);
  454.          gr_infos->table_select[1] = getbits_fast(5);
  455.          /*
  456.           * table_select[2] not needed, because there is no region2,
  457.           * but to satisfy some verifications tools we set it either.
  458.           */
  459.          gr_infos->table_select[2] = 0;
  460.          for(i=0;i<3;i++) {
  461.        unsigned int sbg = (getbits_fast(3)<<3);
  462.            gr_infos->full_gain[i] = gr_infos->pow2gain + sbg;
  463.        if (mpg123_pinfo!=NULL)
  464.          mpg123_pinfo->sub_gain[0][ch][i]=sbg/8;
  465.  
  466.      }
  467.  
  468.          if(gr_infos->block_type == 0) {
  469.            fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n");
  470.            exit(1);
  471.          }
  472.          /* region_count/start parameters are implicit in this case. */       
  473. /* check this again! */
  474.          if(gr_infos->block_type == 2)
  475.            gr_infos->region1start = 36>>1;
  476.          else if(sfreq == 8)
  477. /* check this for 2.5 and sfreq=8 */
  478.            gr_infos->region1start = 108>>1;
  479.          else
  480.            gr_infos->region1start = 54>>1;
  481.          gr_infos->region2start = 576>>1;
  482.        }
  483.        else 
  484.        {
  485.          int i,r0c,r1c;
  486.          for (i=0; i<3; i++)
  487.            gr_infos->table_select[i] = getbits_fast(5);
  488.          r0c = getbits_fast(4);
  489.          r1c = getbits_fast(3);
  490.          gr_infos->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ;
  491.          gr_infos->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1;
  492.          gr_infos->block_type = 0;
  493.          gr_infos->mixed_block_flag = 0;
  494.        }
  495.        gr_infos->scalefac_scale = get1bit();
  496.        gr_infos->count1table_select = get1bit();
  497.    }
  498. }
  499.  
  500. /*
  501.  * read scalefactors
  502.  */
  503. #ifdef MPEG1
  504. static int III_get_scale_factors_1(int *scf,struct gr_info_s *gr_infos)
  505. {
  506.    static unsigned char slen[2][16] = {
  507.      {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  508.      {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
  509.    };
  510.    int numbits;
  511.    int num0 = slen[0][gr_infos->scalefac_compress];
  512.    int num1 = slen[1][gr_infos->scalefac_compress];
  513.  
  514.     if (gr_infos->block_type == 2) 
  515.     {
  516.       int i=18;
  517.       numbits = (num0 + num1) * 18;
  518.  
  519.       if (gr_infos->mixed_block_flag) {
  520.          for (i=8;i;i--)
  521.            *scf++ = getbits_fast(num0);
  522.          i = 9;
  523.          numbits -= num0; /* num0 * 17 + num1 * 18 */
  524.       }
  525.  
  526.       for (;i;i--)
  527.         *scf++ = getbits_fast(num0);
  528.       for (i = 18; i; i--)
  529.         *scf++ = getbits_fast(num1);
  530.       *scf++ = 0; *scf++ = 0; *scf++ = 0; /* short[13][0..2] = 0 */
  531.     }
  532.     else 
  533.     {
  534.       int i;
  535.       int scfsi = gr_infos->scfsi;
  536.  
  537.       if(scfsi < 0) { /* scfsi < 0 => granule == 0 */
  538.          for(i=11;i;i--)
  539.            *scf++ = getbits_fast(num0);
  540.          for(i=10;i;i--)
  541.            *scf++ = getbits_fast(num1);
  542.          numbits = (num0 + num1) * 10 + num0;
  543.       }
  544.       else {
  545.         numbits = 0;
  546.         if(!(scfsi & 0x8)) {
  547.           for (i=6;i;i--)
  548.             *scf++ = getbits_fast(num0);
  549.           numbits += num0 * 6;
  550.         }
  551.         else {
  552.           scf += 6;
  553.         }
  554.  
  555.         if(!(scfsi & 0x4)) {
  556.           for (i=5;i;i--)
  557.             *scf++ = getbits_fast(num0);
  558.           numbits += num0 * 5;
  559.         }
  560.         else {
  561.           scf += 5;
  562.         }
  563.  
  564.         if(!(scfsi & 0x2)) {
  565.           for(i=5;i;i--)
  566.             *scf++ = getbits_fast(num1);
  567.           numbits += num1 * 5;
  568.         }
  569.         else {
  570.           scf += 5;
  571.         }
  572.  
  573.         if(!(scfsi & 0x1)) {
  574.           for (i=5;i;i--)
  575.             *scf++ = getbits_fast(num1);
  576.           numbits += num1 * 5;
  577.         }
  578.         else {
  579.           scf += 5;
  580.         }
  581.       }
  582.  
  583.       *scf++ = 0;  /* no l[21] in original sources */
  584.     }
  585.     return numbits;
  586. }
  587. #endif
  588.  
  589. static int III_get_scale_factors_2(int *scf,struct gr_info_s *gr_infos,int i_stereo)
  590. {
  591.   unsigned char *pnt;
  592.   int i,j;
  593.   unsigned int slen;
  594.   int n = 0;
  595.   int numbits = 0;
  596.  
  597.   static unsigned char stab[3][6][4] = {
  598.    { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
  599.      { 7, 7, 7,0 } , { 6, 6, 6,3 } , {  8, 8,5,0} } ,
  600.    { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
  601.      {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
  602.    { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
  603.      { 6,15,12,0 } , { 6,12, 9,6 } , {  6,18,9,0} } }; 
  604.  
  605.   if(i_stereo) /* i_stereo AND second channel -> do_layer3() checks this */
  606.     slen = i_slen2[gr_infos->scalefac_compress>>1];
  607.   else
  608.     slen = n_slen2[gr_infos->scalefac_compress];
  609.  
  610.   gr_infos->preflag = (slen>>15) & 0x1;
  611.  
  612.   n = 0;  
  613.   if( gr_infos->block_type == 2 ) {
  614.     n++;
  615.     if(gr_infos->mixed_block_flag)
  616.       n++;
  617.   }
  618.  
  619.   pnt = stab[n][(slen>>12)&0x7];
  620.  
  621.   for(i=0;i<4;i++) {
  622.     int num = slen & 0x7;
  623.     slen >>= 3;
  624.     if(num) {
  625.       for(j=0;j<(int)(pnt[i]);j++)
  626.         *scf++ = getbits_fast(num);
  627.       numbits += pnt[i] * num;
  628.     }
  629.     else {
  630.       for(j=0;j<(int)(pnt[i]);j++)
  631.         *scf++ = 0;
  632.     }
  633.   }
  634.   
  635.   n = (n << 1) + 1;
  636.   for(i=0;i<n;i++)
  637.     *scf++ = 0;
  638.  
  639.   return numbits;
  640. }
  641.  
  642. static int pretab1[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
  643. static int pretab2[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  644.  
  645. /*
  646.  * don't forget to apply the same changes to III_dequantize_sample_ms() !!! 
  647.  */
  648. static int III_dequantize_sample(real xr[SBLIMIT][SSLIMIT],int *scf,
  649.    struct gr_info_s *gr_infos,int sfreq,int part2bits)
  650. {
  651.   int shift = 1 + gr_infos->scalefac_scale;
  652.   real *xrpnt = (real *) xr;
  653.   int l[3],l3;
  654.   int part2remain = gr_infos->part2_3_length - part2bits;
  655.   int *me;
  656.  
  657.   {
  658.     int i;
  659.     
  660.     for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i>0;i--) {
  661.       *xrpnt++ = 0.0;
  662.       *xrpnt++ = 0.0;
  663.     }
  664.  
  665.     xrpnt = (real *) xr;
  666.   }
  667.  
  668.   {
  669.     int bv       = gr_infos->big_values;
  670.     int region1  = gr_infos->region1start;
  671.     int region2  = gr_infos->region2start;
  672.  
  673.     l3 = ((576>>1)-bv)>>1;   
  674. /*
  675.  * we may lose the 'odd' bit here !! 
  676.  * check this later again 
  677.  */
  678.     if(bv <= region1) {
  679.       l[0] = bv; l[1] = 0; l[2] = 0;
  680.     }
  681.     else {
  682.       l[0] = region1;
  683.       if(bv <= region2) {
  684.         l[1] = bv - l[0];  l[2] = 0;
  685.       }
  686.       else {
  687.         l[1] = region2 - l[0]; l[2] = bv - region2;
  688.       }
  689.     }
  690.   }
  691.  
  692.   if(gr_infos->block_type == 2) {
  693.     /*
  694.      * decoding with short or mixed mode BandIndex table 
  695.      */
  696.     int i,max[4];
  697.     int step=0,lwin=0,cb=0;
  698.     register real v = 0.0;
  699.     register int *m,mc;
  700.  
  701.     if(gr_infos->mixed_block_flag) {
  702.       max[3] = -1;
  703.       max[0] = max[1] = max[2] = 2;
  704.       m = map[sfreq][0];
  705.       me = mapend[sfreq][0];
  706.     }
  707.     else {
  708.       max[0] = max[1] = max[2] = max[3] = -1;
  709.       /* max[3] not really needed in this case */
  710.       m = map[sfreq][1];
  711.       me = mapend[sfreq][1];
  712.     }
  713.  
  714.     mc = 0;
  715.     for(i=0;i<2;i++) {
  716.       int lp = l[i];
  717.       struct newhuff *h = ht+gr_infos->table_select[i];
  718.       for(;lp;lp--,mc--) {
  719.         register int x,y;
  720.         if( (!mc) ) {
  721.           mc = *m++;
  722.           xrpnt = ((real *) xr) + (*m++);
  723.           lwin = *m++;
  724.           cb = *m++;
  725.           if(lwin == 3) {
  726.             v = gr_infos->pow2gain[(*scf++) << shift];
  727.             step = 1;
  728.           }
  729.           else {
  730.             v = gr_infos->full_gain[lwin][(*scf++) << shift];
  731.             step = 3;
  732.           }
  733.         }
  734.         {
  735.           register short *val = h->table;
  736.           while((y=*val++)<0) {
  737.             if (get1bit())
  738.               val -= y;
  739.             part2remain--;
  740.           }
  741.           x = y >> 4;
  742.           y &= 0xf;
  743.         }
  744.         if(x == 15) {
  745.           max[lwin] = cb;
  746.           part2remain -= h->linbits+1;
  747.           x += getbits((int)h->linbits);
  748.           if(get1bit())
  749.             *xrpnt = -ispow[x] * v;
  750.           else
  751.             *xrpnt =  ispow[x] * v;
  752.         }
  753.         else if(x) {
  754.           max[lwin] = cb;
  755.           if(get1bit())
  756.             *xrpnt = -ispow[x] * v;
  757.           else
  758.             *xrpnt =  ispow[x] * v;
  759.           part2remain--;
  760.         }
  761.         else
  762.           *xrpnt = 0.0;
  763.         xrpnt += step;
  764.         if(y == 15) {
  765.           max[lwin] = cb;
  766.           part2remain -= h->linbits+1;
  767.           y += getbits((int)h->linbits);
  768.           if(get1bit())
  769.             *xrpnt = -ispow[y] * v;
  770.           else
  771.             *xrpnt =  ispow[y] * v;
  772.         }
  773.         else if(y) {
  774.           max[lwin] = cb;
  775.           if(get1bit())
  776.             *xrpnt = -ispow[y] * v;
  777.           else
  778.             *xrpnt =  ispow[y] * v;
  779.           part2remain--;
  780.         }
  781.         else
  782.           *xrpnt = 0.0;
  783.         xrpnt += step;
  784.       }
  785.     }
  786.     for(;l3 && (part2remain > 0);l3--) {
  787.       struct newhuff *h = htc+gr_infos->count1table_select;
  788.       register short *val = h->table,a;
  789.  
  790.       while((a=*val++)<0) {
  791.         part2remain--;
  792.         if(part2remain < 0) {
  793.           part2remain++;
  794.           a = 0;
  795.           break;
  796.         }
  797.         if (get1bit())
  798.           val -= a;
  799.       }
  800.       for(i=0;i<4;i++) {
  801.         if(!(i & 1)) {
  802.           if(!mc) {
  803.             mc = *m++;
  804.             xrpnt = ((real *) xr) + (*m++);
  805.             lwin = *m++;
  806.             cb = *m++;
  807.             if(lwin == 3) {
  808.               v = gr_infos->pow2gain[(*scf++) << shift];
  809.               step = 1;
  810.             }
  811.             else {
  812.               v = gr_infos->full_gain[lwin][(*scf++) << shift];
  813.               step = 3;
  814.             }
  815.           }
  816.           mc--;
  817.         }
  818.         if( (a & (0x8>>i)) ) {
  819.           max[lwin] = cb;
  820.           part2remain--;
  821.           if(part2remain < 0) {
  822.             part2remain++;
  823.             break;
  824.           }
  825.           if(get1bit()) 
  826.             *xrpnt = -v;
  827.           else
  828.             *xrpnt = v;
  829.         }
  830.         else
  831.           *xrpnt = 0.0;
  832.         xrpnt += step;
  833.       }
  834.     }
  835.  
  836.     while( m < me ) {
  837.       if(!mc) {
  838.         mc = *m++;
  839.         xrpnt = ((real *) xr) + *m++;
  840.         if( (*m++) == 3)
  841.           step = 1;
  842.         else
  843.           step = 3;
  844.         m++; /* cb */
  845.       }
  846.       mc--;
  847.       *xrpnt = 0.0;
  848.       xrpnt += step;
  849.       *xrpnt = 0.0;
  850.       xrpnt += step;
  851. /* we could add a little opt. here:
  852.  * if we finished a band for window 3 or a long band
  853.  * further bands could copied in a simple loop without a
  854.  * special 'map' decoding
  855.  */
  856.     }
  857.  
  858.     gr_infos->maxband[0] = max[0]+1;
  859.     gr_infos->maxband[1] = max[1]+1;
  860.     gr_infos->maxband[2] = max[2]+1;
  861.     gr_infos->maxbandl = max[3]+1;
  862.  
  863.     {
  864.       int rmax = max[0] > max[1] ? max[0] : max[1];
  865.       rmax = (rmax > max[2] ? rmax : max[2]) + 1;
  866.       gr_infos->maxb = rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3]+1];
  867.     }
  868.  
  869.   }
  870.   else {
  871.     /*
  872.      * decoding with 'long' BandIndex table (block_type != 2)
  873.      */
  874.     int *pretab = gr_infos->preflag ? pretab1 : pretab2;
  875.     int i,max = -1;
  876.     int cb = 0;
  877.     register int *m = map[sfreq][2];
  878.     register real v = 0.0;
  879.     register int mc = 0;
  880. #if 0
  881.     me = mapend[sfreq][2];
  882. #endif
  883.  
  884.     /*
  885.      * long hash table values
  886.      */
  887.     for(i=0;i<3;i++) {
  888.       int lp = l[i];
  889.       struct newhuff *h = ht+gr_infos->table_select[i];
  890.  
  891.       for(;lp;lp--,mc--) {
  892.         int x,y;
  893.  
  894.         if(!mc) {
  895.           mc = *m++;
  896.           v = gr_infos->pow2gain[((*scf++) + (*pretab++)) << shift];
  897.           cb = *m++;
  898.         }
  899.         {
  900.           register short *val = h->table;
  901.           while((y=*val++)<0) {
  902.             if (get1bit())
  903.               val -= y;
  904.             part2remain--;
  905.           }
  906.           x = y >> 4;
  907.           y &= 0xf;
  908.         }
  909.         if (x == 15) {
  910.           max = cb;
  911.           part2remain -= h->linbits+1;
  912.           x += getbits((int)h->linbits);
  913.           if(get1bit())
  914.             *xrpnt++ = -ispow[x] * v;
  915.           else
  916.             *xrpnt++ =  ispow[x] * v;
  917.         }
  918.         else if(x) {
  919.           max = cb;
  920.           if(get1bit())
  921.             *xrpnt++ = -ispow[x] * v;
  922.           else
  923.             *xrpnt++ =  ispow[x] * v;
  924.           part2remain--;
  925.         }
  926.         else
  927.           *xrpnt++ = 0.0;
  928.  
  929.         if (y == 15) {
  930.           max = cb;
  931.           part2remain -= h->linbits+1;
  932.           y += getbits((int)h->linbits);
  933.           if(get1bit())
  934.             *xrpnt++ = -ispow[y] * v;
  935.           else
  936.             *xrpnt++ =  ispow[y] * v;
  937.         }
  938.         else if(y) {
  939.           max = cb;
  940.           if(get1bit())
  941.             *xrpnt++ = -ispow[y] * v;
  942.           else
  943.             *xrpnt++ =  ispow[y] * v;
  944.           part2remain--;
  945.         }
  946.         else
  947.           *xrpnt++ = 0.0;
  948.       }
  949.     }
  950.  
  951.     /*
  952.      * short (count1table) values
  953.      */
  954.     for(;l3 && (part2remain > 0);l3--) {
  955.       struct newhuff *h = htc+gr_infos->count1table_select;
  956.       register short *val = h->table,a;
  957.  
  958.       while((a=*val++)<0) {
  959.         part2remain--;
  960.         if(part2remain < 0) {
  961.           part2remain++;
  962.           a = 0;
  963.           break;
  964.         }
  965.         if (get1bit())
  966.           val -= a;
  967.       }
  968.       for(i=0;i<4;i++) {
  969.         if(!(i & 1)) {
  970.           if(!mc) {
  971.             mc = *m++;
  972.             cb = *m++;
  973.             v = gr_infos->pow2gain[((*scf++) + (*pretab++)) << shift];
  974.           }
  975.           mc--;
  976.         }
  977.         if ( (a & (0x8>>i)) ) {
  978.           max = cb;
  979.           part2remain--;
  980.           if(part2remain < 0) {
  981.             part2remain++;
  982.             break;
  983.           }
  984.           if(get1bit())
  985.             *xrpnt++ = -v;
  986.           else
  987.             *xrpnt++ = v;
  988.         }
  989.         else
  990.           *xrpnt++ = 0.0;
  991.       }
  992.     }
  993.  
  994.     /* 
  995.      * zero part
  996.      */
  997.     for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i;i--) {
  998.       *xrpnt++ = 0.0;
  999.       *xrpnt++ = 0.0;
  1000.     }
  1001.  
  1002.     gr_infos->maxbandl = max+1;
  1003.     gr_infos->maxb = longLimit[sfreq][gr_infos->maxbandl];
  1004.   }
  1005.  
  1006.   while( part2remain > 16 ) {
  1007.     getbits(16); /* Dismiss stuffing Bits */
  1008.     part2remain -= 16;
  1009.   }
  1010.   if(part2remain > 0)
  1011.     getbits(part2remain);
  1012.   else if(part2remain < 0) {
  1013.     fprintf(stderr,"mpg123: Can't rewind stream by %d bits!\n",-part2remain);
  1014.     return 1; /* -> error */
  1015.   }
  1016.   return 0;
  1017. }
  1018.  
  1019.  
  1020. /* 
  1021.  * III_stereo: calculate real channel values for Joint-I-Stereo-mode
  1022.  */
  1023. static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac,
  1024.    struct gr_info_s *gr_infos,int sfreq,int ms_stereo,int lsf)
  1025. {
  1026.       real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf;
  1027.       struct bandInfoStruct *bi = &bandInfo[sfreq];
  1028.       real *tabl1,*tabl2;
  1029.  
  1030.       if(lsf) {
  1031.         int p = gr_infos->scalefac_compress & 0x1;
  1032.         if(ms_stereo) {
  1033.           tabl1 = pow1_2[p]; tabl2 = pow2_2[p];
  1034.         }
  1035.         else {
  1036.           tabl1 = pow1_1[p]; tabl2 = pow2_1[p];
  1037.         }
  1038.       }
  1039.       else {
  1040.         if(ms_stereo) {
  1041.           tabl1 = tan1_2; tabl2 = tan2_2;
  1042.         }
  1043.         else {
  1044.           tabl1 = tan1_1; tabl2 = tan2_1;
  1045.         }
  1046.       }
  1047.  
  1048.       if (gr_infos->block_type == 2)
  1049.       {
  1050.          int lwin,do_l = 0;
  1051.          if( gr_infos->mixed_block_flag )
  1052.            do_l = 1;
  1053.  
  1054.          for (lwin=0;lwin<3;lwin++) /* process each window */
  1055.          {
  1056.              /* get first band with zero values */
  1057.            int is_p,sb,idx,sfb = gr_infos->maxband[lwin];  /* sfb is minimal 3 for mixed mode */
  1058.            if(sfb > 3)
  1059.              do_l = 0;
  1060.  
  1061.            for(;sfb<12;sfb++)
  1062.            {
  1063.              is_p = scalefac[sfb*3+lwin-gr_infos->mixed_block_flag]; /* scale: 0-15 */ 
  1064.              if(is_p != 7) {
  1065.                real t1,t2;
  1066.                sb = bi->shortDiff[sfb];
  1067.                idx = bi->shortIdx[sfb] + lwin;
  1068.                t1 = tabl1[is_p]; t2 = tabl2[is_p];
  1069.                for (; sb > 0; sb--,idx+=3)
  1070.                {
  1071.                  real v = xr[0][idx];
  1072.                  xr[0][idx] = v * t1;
  1073.                  xr[1][idx] = v * t2;
  1074.                }
  1075.              }
  1076.            }
  1077.  
  1078. #if 1
  1079. /* in the original: copy 10 to 11 , here: copy 11 to 12 
  1080. maybe still wrong??? (copy 12 to 13?) */
  1081.            is_p = scalefac[11*3+lwin-gr_infos->mixed_block_flag]; /* scale: 0-15 */
  1082.            sb = bi->shortDiff[12];
  1083.            idx = bi->shortIdx[12] + lwin;
  1084. #else
  1085.            is_p = scalefac[10*3+lwin-gr_infos->mixed_block_flag]; /* scale: 0-15 */
  1086.            sb = bi->shortDiff[11];
  1087.            idx = bi->shortIdx[11] + lwin;
  1088. #endif
  1089.            if(is_p != 7)
  1090.            {
  1091.              real t1,t2;
  1092.              t1 = tabl1[is_p]; t2 = tabl2[is_p];
  1093.              for ( ; sb > 0; sb--,idx+=3 )
  1094.              {  
  1095.                real v = xr[0][idx];
  1096.                xr[0][idx] = v * t1;
  1097.                xr[1][idx] = v * t2;
  1098.              }
  1099.            }
  1100.          } /* end for(lwin; .. ; . ) */
  1101.  
  1102.          if (do_l)
  1103.          {
  1104. /* also check l-part, if ALL bands in the three windows are 'empty'
  1105.  * and mode = mixed_mode 
  1106.  */
  1107.            int sfb = gr_infos->maxbandl;
  1108.            int idx = bi->longIdx[sfb];
  1109.  
  1110.            for ( ; sfb<8; sfb++ )
  1111.            {
  1112.              int sb = bi->longDiff[sfb];
  1113.              int is_p = scalefac[sfb]; /* scale: 0-15 */
  1114.              if(is_p != 7) {
  1115.                real t1,t2;
  1116.                t1 = tabl1[is_p]; t2 = tabl2[is_p];
  1117.                for ( ; sb > 0; sb--,idx++)
  1118.                {
  1119.                  real v = xr[0][idx];
  1120.                  xr[0][idx] = v * t1;
  1121.                  xr[1][idx] = v * t2;
  1122.                }
  1123.              }
  1124.              else 
  1125.                idx += sb;
  1126.            }
  1127.          }     
  1128.       } 
  1129.       else /* ((gr_infos->block_type != 2)) */
  1130.       {
  1131.         int sfb = gr_infos->maxbandl;
  1132.         int is_p,idx = bi->longIdx[sfb];
  1133.         for ( ; sfb<21; sfb++)
  1134.         {
  1135.           int sb = bi->longDiff[sfb];
  1136.           is_p = scalefac[sfb]; /* scale: 0-15 */
  1137.           if(is_p != 7) {
  1138.             real t1,t2;
  1139.             t1 = tabl1[is_p]; t2 = tabl2[is_p];
  1140.             for ( ; sb > 0; sb--,idx++)
  1141.             {
  1142.                real v = xr[0][idx];
  1143.                xr[0][idx] = v * t1;
  1144.                xr[1][idx] = v * t2;
  1145.             }
  1146.           }
  1147.           else
  1148.             idx += sb;
  1149.         }
  1150.  
  1151.         is_p = scalefac[20]; /* copy l-band 20 to l-band 21 */
  1152.         if(is_p != 7)
  1153.         {
  1154.           int sb;
  1155.           real t1 = tabl1[is_p],t2 = tabl2[is_p]; 
  1156.  
  1157.           for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ )
  1158.           {
  1159.             real v = xr[0][idx];
  1160.             xr[0][idx] = v * t1;
  1161.             xr[1][idx] = v * t2;
  1162.           }
  1163.         }
  1164.       } /* ... */
  1165. }
  1166.  
  1167. static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_infos)
  1168. {
  1169.    int sblim;
  1170.  
  1171.    if(gr_infos->block_type == 2)
  1172.    {
  1173.       if(!gr_infos->mixed_block_flag) 
  1174.         return;
  1175.       sblim = 1; 
  1176.    }
  1177.    else {
  1178.      sblim = gr_infos->maxb-1;
  1179.    }
  1180.  
  1181.    /* 31 alias-reduction operations between each pair of sub-bands */
  1182.    /* with 8 butterflies between each pair                         */
  1183.  
  1184.    {
  1185.      int sb;
  1186.      real *xr1=(real *) xr[1];
  1187.  
  1188.      for(sb=sblim;sb;sb--,xr1+=10)
  1189.      {
  1190.        int ss;
  1191.        real *cs=aa_cs,*ca=aa_ca;
  1192.        real *xr2 = xr1;
  1193.  
  1194.        for(ss=7;ss>=0;ss--)
  1195.        {       /* upper and lower butterfly inputs */
  1196.          register real bu = *--xr2,bd = *xr1;
  1197.          *xr2   = (bu * (*cs)   ) - (bd * (*ca)   );
  1198.          *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );
  1199.        }
  1200.      }
  1201.   }
  1202. }
  1203.  
  1204. /*
  1205.  DCT insipired by Jeff Tsay's DCT from the maplay package
  1206.  this is an optimized version with manual unroll.
  1207.  
  1208.  References:
  1209.  [1] S. Winograd: "On Computing the Discrete Fourier Transform",
  1210.      Mathematics of Computation, Volume 32, Number 141, January 1978,
  1211.      Pages 175-199
  1212. */
  1213.  
  1214. static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf)
  1215. {
  1216.   {
  1217.     register real *in = inbuf;
  1218.  
  1219.     in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14];
  1220.     in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11];
  1221.     in[11]+=in[10]; in[10]+=in[9];  in[9] +=in[8];
  1222.     in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
  1223.     in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];
  1224.     in[2] +=in[1];  in[1] +=in[0];
  1225.  
  1226.     in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
  1227.     in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
  1228.  
  1229.  
  1230.   {
  1231.  
  1232. #define MACRO0(v) { \
  1233.     real tmp; \
  1234.     out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; \
  1235.     out2[8-(v)] = tmp * w[26-(v)];  } \
  1236.     sum0 -= sum1; \
  1237.     ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; \
  1238.     ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; 
  1239. #define MACRO1(v) { \
  1240.     real sum0,sum1; \
  1241.     sum0 = tmp1a + tmp2a; \
  1242.     sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; \
  1243.     MACRO0(v); }
  1244. #define MACRO2(v) { \
  1245.     real sum0,sum1; \
  1246.     sum0 = tmp2a - tmp1a; \
  1247.     sum1 = (tmp2b - tmp1b) * tfcos36[(v)]; \
  1248.     MACRO0(v); }
  1249.  
  1250.     register const real *c = COS9;
  1251.     register real *out2 = o2;
  1252.     register real *w = wintab;
  1253.     register real *out1 = o1;
  1254.     register real *ts = tsbuf;
  1255.  
  1256.     real ta33,ta66,tb33,tb66;
  1257.  
  1258.     ta33 = in[2*3+0] * c[3];
  1259.     ta66 = in[2*6+0] * c[6];
  1260.     tb33 = in[2*3+1] * c[3];
  1261.     tb66 = in[2*6+1] * c[6];
  1262.  
  1263.     { 
  1264.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1265.       tmp1a =             in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7];
  1266.       tmp1b =             in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7];
  1267.       tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8];
  1268.       tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8];
  1269.  
  1270.       MACRO1(0);
  1271.       MACRO2(8);
  1272.     }
  1273.  
  1274.     {
  1275.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1276.       tmp1a = ( in[2*1+0] - in[2*5+0] - in[2*7+0] ) * c[3];
  1277.       tmp1b = ( in[2*1+1] - in[2*5+1] - in[2*7+1] ) * c[3];
  1278.       tmp2a = ( in[2*2+0] - in[2*4+0] - in[2*8+0] ) * c[6] - in[2*6+0] + in[2*0+0];
  1279.       tmp2b = ( in[2*2+1] - in[2*4+1] - in[2*8+1] ) * c[6] - in[2*6+1] + in[2*0+1];
  1280.  
  1281.       MACRO1(1);
  1282.       MACRO2(7);
  1283.     }
  1284.  
  1285.     {
  1286.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1287.       tmp1a =             in[2*1+0] * c[5] - ta33 - in[2*5+0] * c[7] + in[2*7+0] * c[1];
  1288.       tmp1b =             in[2*1+1] * c[5] - tb33 - in[2*5+1] * c[7] + in[2*7+1] * c[1];
  1289.       tmp2a = in[2*0+0] - in[2*2+0] * c[8] - in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4];
  1290.       tmp2b = in[2*0+1] - in[2*2+1] * c[8] - in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4];
  1291.  
  1292.       MACRO1(2);
  1293.       MACRO2(6);
  1294.     }
  1295.  
  1296.     {
  1297.       real tmp1a,tmp2a,tmp1b,tmp2b;
  1298.       tmp1a =             in[2*1+0] * c[7] - ta33 + in[2*5+0] * c[1] - in[2*7+0] * c[5];
  1299.       tmp1b =             in[2*1+1] * c[7] - tb33 + in[2*5+1] * c[1] - in[2*7+1] * c[5];
  1300.       tmp2a = in[2*0+0] - in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66 - in[2*8+0] * c[2];
  1301.       tmp2b = in[2*0+1] - in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66 - in[2*8+1] * c[2];
  1302.  
  1303.       MACRO1(3);
  1304.       MACRO2(5);
  1305.     }
  1306.  
  1307.     {
  1308.         real sum0,sum1;
  1309.         sum0 =  in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0];
  1310.         sum1 = (in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ) * tfcos36[4];
  1311.         MACRO0(4);
  1312.     }
  1313.   }
  1314.  
  1315.   }
  1316. }
  1317.  
  1318. /*
  1319.  * new DCT12
  1320.  */
  1321. static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts)
  1322. {
  1323. #define DCT12_PART1 \
  1324.              in5 = in[5*3];  \
  1325.      in5 += (in4 = in[4*3]); \
  1326.      in4 += (in3 = in[3*3]); \
  1327.      in3 += (in2 = in[2*3]); \
  1328.      in2 += (in1 = in[1*3]); \
  1329.      in1 += (in0 = in[0*3]); \
  1330.                              \
  1331.      in5 += in3; in3 += in1; \
  1332.                              \
  1333.      in2 *= COS6_1; \
  1334.      in3 *= COS6_1; \
  1335.  
  1336. #define DCT12_PART2 \
  1337.      in0 += in4 * COS6_2; \
  1338.                           \
  1339.      in4 = in0 + in2;     \
  1340.      in0 -= in2;          \
  1341.                           \
  1342.      in1 += in5 * COS6_2; \
  1343.                           \
  1344.      in5 = (in1 + in3) * tfcos12[0]; \
  1345.      in1 = (in1 - in3) * tfcos12[2]; \
  1346.                          \
  1347.      in3 = in4 + in5;    \
  1348.      in4 -= in5;         \
  1349.                          \
  1350.      in2 = in0 + in1;    \
  1351.      in0 -= in1;
  1352.  
  1353.  
  1354.    {
  1355.      real in0,in1,in2,in3,in4,in5;
  1356.      register real *out1 = rawout1;
  1357.      ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2];
  1358.      ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5];
  1359.  
  1360.      DCT12_PART1
  1361.  
  1362.      {
  1363.        real tmp0,tmp1 = (in0 - in4);
  1364.        {
  1365.          real tmp2 = (in1 - in5) * tfcos12[1];
  1366.          tmp0 = tmp1 + tmp2;
  1367.          tmp1 -= tmp2;
  1368.        }
  1369.        ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1];
  1370.        ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1];
  1371.        ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1];
  1372.        ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1];
  1373.      }
  1374.  
  1375.      DCT12_PART2
  1376.  
  1377.      ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0];
  1378.      ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0];
  1379.      ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2];
  1380.      ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2];
  1381.  
  1382.      ts[(6+0)*SBLIMIT]  = out1[6+0] + in0 * wi[0];
  1383.      ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0];
  1384.      ts[(6+2)*SBLIMIT]  = out1[6+2] + in4 * wi[2];
  1385.      ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2];
  1386.   }
  1387.  
  1388.   in++;
  1389.  
  1390.   {
  1391.      real in0,in1,in2,in3,in4,in5;
  1392.      register real *out2 = rawout2;
  1393.  
  1394.      DCT12_PART1
  1395.  
  1396.      {
  1397.        real tmp0,tmp1 = (in0 - in4);
  1398.        {
  1399.          real tmp2 = (in1 - in5) * tfcos12[1];
  1400.          tmp0 = tmp1 + tmp2;
  1401.          tmp1 -= tmp2;
  1402.        }
  1403.        out2[5-1] = tmp0 * wi[11-1];
  1404.        out2[0+1] = tmp0 * wi[6+1];
  1405.        ts[(12+1)*SBLIMIT] += tmp1 * wi[1];
  1406.        ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1];
  1407.      }
  1408.  
  1409.      DCT12_PART2
  1410.  
  1411.      out2[5-0] = in2 * wi[11-0];
  1412.      out2[0+0] = in2 * wi[6+0];
  1413.      out2[0+2] = in3 * wi[6+2];
  1414.      out2[5-2] = in3 * wi[11-2];
  1415.  
  1416.      ts[(12+0)*SBLIMIT] += in0 * wi[0];
  1417.      ts[(17-0)*SBLIMIT] += in0 * wi[5-0];
  1418.      ts[(12+2)*SBLIMIT] += in4 * wi[2];
  1419.      ts[(17-2)*SBLIMIT] += in4 * wi[5-2];
  1420.   }
  1421.  
  1422.   in++; 
  1423.  
  1424.   {
  1425.      real in0,in1,in2,in3,in4,in5;
  1426.      register real *out2 = rawout2;
  1427.      out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0;
  1428.  
  1429.      DCT12_PART1
  1430.  
  1431.      {
  1432.        real tmp0,tmp1 = (in0 - in4);
  1433.        {
  1434.          real tmp2 = (in1 - in5) * tfcos12[1];
  1435.          tmp0 = tmp1 + tmp2;
  1436.          tmp1 -= tmp2;
  1437.        }
  1438.        out2[11-1] = tmp0 * wi[11-1];
  1439.        out2[6 +1] = tmp0 * wi[6+1];
  1440.        out2[0+1] += tmp1 * wi[1];
  1441.        out2[5-1] += tmp1 * wi[5-1];
  1442.      }
  1443.  
  1444.      DCT12_PART2
  1445.  
  1446.      out2[11-0] = in2 * wi[11-0];
  1447.      out2[6 +0] = in2 * wi[6+0];
  1448.      out2[6 +2] = in3 * wi[6+2];
  1449.      out2[11-2] = in3 * wi[11-2];
  1450.  
  1451.      out2[0+0] += in0 * wi[0];
  1452.      out2[5-0] += in0 * wi[5-0];
  1453.      out2[0+2] += in4 * wi[2];
  1454.      out2[5-2] += in4 * wi[5-2];
  1455.   }
  1456. }
  1457.  
  1458. /*
  1459.  * III_hybrid
  1460.  */
  1461. static void III_hybrid(real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT],
  1462.    int ch,struct gr_info_s *gr_infos)
  1463. {
  1464.    real *tspnt = (real *) tsOut;
  1465.    real (*block)[2][SBLIMIT*SSLIMIT] = gmp->hybrid_block;
  1466.    int *blc = gmp->hybrid_blc;
  1467.    real *rawout1,*rawout2;
  1468.    int bt;
  1469.    int sb = 0;
  1470.  
  1471.    {
  1472.      int b = blc[ch];
  1473.      rawout1=block[b][ch];
  1474.      b=-b+1;
  1475.      rawout2=block[b][ch];
  1476.      blc[ch] = b;
  1477.    }
  1478.  
  1479.   
  1480.    if(gr_infos->mixed_block_flag) {
  1481.      sb = 2;
  1482.      dct36(fsIn[0],rawout1,rawout2,win[0],tspnt);
  1483.      dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1);
  1484.      rawout1 += 36; rawout2 += 36; tspnt += 2;
  1485.    }
  1486.  
  1487.    bt = gr_infos->block_type;
  1488.    if(bt == 2) {
  1489.      for (; sb<gr_infos->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
  1490.        dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt);
  1491.        dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1);
  1492.      }
  1493.    }
  1494.    else {
  1495.      for (; sb<gr_infos->maxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) {
  1496.        dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt);
  1497.        dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1);
  1498.      }
  1499.    }
  1500.  
  1501.    for(;sb<SBLIMIT;sb++,tspnt++) {
  1502.      int i;
  1503.      for(i=0;i<SSLIMIT;i++) {
  1504.        tspnt[i*SBLIMIT] = *rawout1++;
  1505.        *rawout2++ = 0.0;
  1506.      }
  1507.    }
  1508. }
  1509.  
  1510. /*
  1511.  * main layer3 handler
  1512.  */
  1513. struct III_sideinfo sideinfo;
  1514.  
  1515. int do_layer3_sideinfo(struct frame *fr)
  1516. {
  1517.   int stereo = fr->stereo;
  1518.   int single = fr->single;
  1519.   int ms_stereo;
  1520.   int sfreq = fr->sampling_frequency;
  1521.   int granules;
  1522.   int ch,gr,databits;
  1523.  
  1524.   if(stereo == 1) { /* stream is mono */
  1525.     single = 0;
  1526.   }
  1527.  
  1528.   if(fr->mode == MPG_MD_JOINT_STEREO) {
  1529.     ms_stereo = fr->mode_ext & 0x2;
  1530.   }
  1531.   else
  1532.     ms_stereo = 0;
  1533.  
  1534.  
  1535.   if(fr->lsf) {
  1536.     granules = 1;
  1537.     III_get_side_info_2(&sideinfo,stereo,ms_stereo,sfreq,single);
  1538.   }
  1539.   else {
  1540.     granules = 2;
  1541. #ifdef MPEG1
  1542.     III_get_side_info_1(&sideinfo,stereo,ms_stereo,sfreq,single);
  1543. #else
  1544.     fprintf(stderr,"Not supported\n");
  1545. #endif
  1546.   }
  1547.  
  1548.   databits=0;
  1549.   for (gr=0 ; gr < granules ; ++gr) {
  1550.     for (ch=0; ch < stereo ; ++ch) {
  1551.       struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
  1552.       databits += gr_infos->part2_3_length;
  1553.     }
  1554.   }
  1555.   return databits-8*sideinfo.main_data_begin;
  1556. }
  1557.  
  1558.  
  1559.  
  1560. int do_layer3(struct frame *fr,unsigned char *pcm_sample,int *pcm_point)
  1561. {
  1562.   int gr, ch, ss,clip=0;
  1563.   int scalefacs[2][39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */
  1564.   //  struct III_sideinfo sideinfo;
  1565.   int stereo = fr->stereo;
  1566.   int single = fr->single;
  1567.   int ms_stereo,i_stereo;
  1568.   int sfreq = fr->sampling_frequency;
  1569.   int stereo1,granules;
  1570.  
  1571.   if(set_pointer((int)sideinfo.main_data_begin) == MP3_ERR)
  1572.     return 0;
  1573.  
  1574.   if(stereo == 1) { /* stream is mono */
  1575.     stereo1 = 1;
  1576.     single = 0;
  1577.   }
  1578.   else if(single >= 0) /* stream is stereo, but force to mono */
  1579.     stereo1 = 1;
  1580.   else
  1581.     stereo1 = 2;
  1582.  
  1583.   if(fr->mode == MPG_MD_JOINT_STEREO) {
  1584.     ms_stereo = fr->mode_ext & 0x2;
  1585.     i_stereo  = fr->mode_ext & 0x1;
  1586.   }
  1587.   else
  1588.     ms_stereo = i_stereo = 0;
  1589.  
  1590.  
  1591.   if(fr->lsf) {
  1592.     granules = 1;
  1593.   }
  1594.   else {
  1595.     granules = 2;
  1596.   }
  1597.  
  1598.  
  1599.   for (gr=0;gr<granules;gr++) 
  1600.   {
  1601.     static real hybridIn[2][SBLIMIT][SSLIMIT];
  1602.     static real hybridOut[2][SSLIMIT][SBLIMIT];
  1603.  
  1604.     {
  1605.       struct gr_info_s *gr_infos = &(sideinfo.ch[0].gr[gr]);
  1606.       long part2bits;
  1607.  
  1608.       if(fr->lsf)
  1609.         part2bits = III_get_scale_factors_2(scalefacs[0],gr_infos,0);
  1610.       else {
  1611. #ifdef MPEG1
  1612.         part2bits = III_get_scale_factors_1(scalefacs[0],gr_infos);
  1613. #else
  1614.     fprintf(stderr,"Not supported\n");
  1615. #endif
  1616.       }
  1617.  
  1618.       if (mpg123_pinfo!=NULL) {
  1619.     int i;
  1620.     mpg123_pinfo->sfbits[gr][0] = part2bits;
  1621.     for (i=0; i<39; i++) 
  1622.       mpg123_pinfo->sfb_s[gr][0][i]=scalefacs[0][i];
  1623.       }
  1624.  
  1625.       if(III_dequantize_sample(hybridIn[0], scalefacs[0],gr_infos,sfreq,part2bits))
  1626.         return clip;
  1627.     }
  1628.     if(stereo == 2) {
  1629.       struct gr_info_s *gr_infos = &(sideinfo.ch[1].gr[gr]);
  1630.       long part2bits;
  1631.       if(fr->lsf) 
  1632.         part2bits = III_get_scale_factors_2(scalefacs[1],gr_infos,i_stereo);
  1633.       else {
  1634. #ifdef MPEG1
  1635.         part2bits = III_get_scale_factors_1(scalefacs[1],gr_infos);
  1636. #else
  1637.     fprintf(stderr,"Not supported\n");
  1638. #endif
  1639.       }
  1640.       if (mpg123_pinfo!=NULL) {
  1641.     int i;
  1642.     mpg123_pinfo->sfbits[gr][1] = part2bits;
  1643.     for (i=0; i<39; i++) 
  1644.       mpg123_pinfo->sfb_s[gr][1][i]=scalefacs[1][i];
  1645.       }
  1646.  
  1647.       if(III_dequantize_sample(hybridIn[1],scalefacs[1],gr_infos,sfreq,part2bits))
  1648.           return clip;
  1649.  
  1650.       if(ms_stereo) {
  1651.         int i;
  1652.         for(i=0;i<SBLIMIT*SSLIMIT;i++) {
  1653.           real tmp0,tmp1;
  1654.           tmp0 = ((real *) hybridIn[0])[i];
  1655.           tmp1 = ((real *) hybridIn[1])[i];
  1656.           ((real *) hybridIn[1])[i] = tmp0 - tmp1;  
  1657.           ((real *) hybridIn[0])[i] = tmp0 + tmp1;
  1658.         }
  1659.       }
  1660.  
  1661.       if(i_stereo)
  1662.         III_i_stereo(hybridIn,scalefacs[1],gr_infos,sfreq,ms_stereo,fr->lsf);
  1663.  
  1664.       if(ms_stereo || i_stereo || (single == 3) ) {
  1665.         if(gr_infos->maxb > sideinfo.ch[0].gr[gr].maxb) 
  1666.           sideinfo.ch[0].gr[gr].maxb = gr_infos->maxb;
  1667.         else
  1668.           gr_infos->maxb = sideinfo.ch[0].gr[gr].maxb;
  1669.       }
  1670.  
  1671.       switch(single) {
  1672.         case 3:
  1673.           {
  1674.             register int i;
  1675.             register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
  1676.             for(i=0;i<SSLIMIT*gr_infos->maxb;i++,in0++)
  1677.               *in0 = (*in0 + *in1++); /* *0.5 done by pow-scale */ 
  1678.           }
  1679.           break;
  1680.         case 1:
  1681.           {
  1682.             register int i;
  1683.             register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1];
  1684.             for(i=0;i<SSLIMIT*gr_infos->maxb;i++)
  1685.               *in0++ = *in1++;
  1686.           }
  1687.           break;
  1688.       }
  1689.     }
  1690.  
  1691.     if (mpg123_pinfo!=NULL) {
  1692.     extern int tabsel_123[2][3][16];
  1693.     extern int pretab[21];
  1694.     int i,sb;
  1695.     float ifqstep;
  1696.  
  1697.     mpg123_pinfo->bitrate = 
  1698.       tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index];
  1699.     mpg123_pinfo->sampfreq = freqs[sfreq];
  1700.     mpg123_pinfo->emph = fr->emphasis;
  1701.     mpg123_pinfo->crc = fr->error_protection;
  1702.     mpg123_pinfo->padding = fr->padding;
  1703.     mpg123_pinfo->stereo = fr->stereo;
  1704.     mpg123_pinfo->js =   (fr->mode == MPG_MD_JOINT_STEREO);
  1705.     mpg123_pinfo->ms_stereo = ms_stereo;
  1706.     mpg123_pinfo->i_stereo = i_stereo;
  1707.     mpg123_pinfo->maindata = sideinfo.main_data_begin;
  1708.  
  1709.     for(ch=0;ch<stereo1;ch++) {
  1710.       struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
  1711.       mpg123_pinfo->big_values[gr][ch]=gr_infos->big_values;
  1712.       mpg123_pinfo->scalefac_scale[gr][ch]=gr_infos->scalefac_scale;
  1713.       mpg123_pinfo->mixed[gr][ch] = gr_infos->mixed_block_flag;
  1714.       mpg123_pinfo->mpg123blocktype[gr][ch]=gr_infos->block_type;
  1715.       mpg123_pinfo->mainbits[gr][ch] = gr_infos->part2_3_length;
  1716.       mpg123_pinfo->preflag[gr][ch] = gr_infos->preflag;
  1717.       if (gr==1) mpg123_pinfo->scfsi[ch] = gr_infos->scfsi;
  1718.     }
  1719.  
  1720.  
  1721.     for (ch=0;ch<stereo1;ch++) {
  1722.       struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
  1723.       ifqstep = ( mpg123_pinfo->scalefac_scale[gr][ch] == 0 ) ? .5 : 1.0;
  1724.       if (2==gr_infos->block_type) {
  1725.     for (i=0; i<3; i++) {
  1726.       for (sb=0; sb<12; sb++) {
  1727.         int j = 3*sb+i;
  1728.         /*
  1729.            is_p = scalefac[sfb*3+lwin-gr_infos->mixed_block_flag]; 
  1730.         */
  1731.         /* scalefac was copied into mpg123_pinfo->sfb_s[] above */
  1732.         mpg123_pinfo->sfb_s[gr][ch][j] = -ifqstep*mpg123_pinfo->sfb_s[gr][ch][j-gr_infos->mixed_block_flag];
  1733.         mpg123_pinfo->sfb_s[gr][ch][j] -= 2*(mpg123_pinfo->sub_gain[gr][ch][i]);
  1734.       }
  1735.       mpg123_pinfo->sfb_s[gr][ch][3*sb+i] = - 2*(mpg123_pinfo->sub_gain[gr][ch][i]);
  1736.     }
  1737.       }else{
  1738.     for (sb=0; sb<21; sb++) {
  1739.       /* scalefac was copied into mpg123_pinfo->sfb[] above */
  1740.       mpg123_pinfo->sfb[gr][ch][sb] = mpg123_pinfo->sfb_s[gr][ch][sb];
  1741.       if (gr_infos->preflag) mpg123_pinfo->sfb[gr][ch][sb] += pretab[sb];
  1742.       mpg123_pinfo->sfb[gr][ch][sb] *= -ifqstep;
  1743.     }
  1744.     mpg123_pinfo->sfb[gr][ch][21]=0;
  1745.       }
  1746.     }
  1747.  
  1748.  
  1749.     
  1750.     for(ch=0;ch<stereo1;ch++) { 
  1751.       int j=0;
  1752.       for (sb=0;sb<SBLIMIT;sb++)
  1753.     for(ss=0;ss<SSLIMIT;ss++,j++) 
  1754.       mpg123_pinfo->mpg123xr[gr][ch][j]=hybridIn[ch][sb][ss];
  1755.     }
  1756.   }
  1757.  
  1758.  
  1759.     for(ch=0;ch<stereo1;ch++) {
  1760.       struct gr_info_s *gr_infos = &(sideinfo.ch[ch].gr[gr]);
  1761.       III_antialias(hybridIn[ch],gr_infos);
  1762.       III_hybrid(hybridIn[ch], hybridOut[ch], ch,gr_infos);
  1763.     }
  1764.  
  1765.     for(ss=0;ss<SSLIMIT;ss++) {
  1766.       if(single >= 0) {
  1767.         clip += synth_1to1_mono(hybridOut[0][ss],pcm_sample,pcm_point);
  1768.       }
  1769.       else {
  1770.         int p1 = *pcm_point;
  1771.         clip += synth_1to1(hybridOut[0][ss],0,pcm_sample,&p1);
  1772.         clip += synth_1to1(hybridOut[1][ss],1,pcm_sample,pcm_point);
  1773.       }
  1774.     }
  1775.   }
  1776.   
  1777.   return clip;
  1778. }
  1779.  
  1780.  
  1781.  
  1782. #endif
  1783.